home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 January: Mac OS SDK / Dev.CD Jan 97 SDK2.toast / Development Kits (Disc 2) / OpenDoc / OpenDoc Development / Debugging Support / OpenDoc™ Source Code / Storage / Bento / CM / CMAPI.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-28  |  13.5 KB  |  294 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        CMAPI.h
  3.  
  4.     Contains:    Container Manager API
  5.  
  6.     Owned by:    Ira L. Ruben
  7.  
  8.     Owned by:    Ed Lai
  9.  
  10.     Copyright:    © 1991 - 1996 by Apple Computer, Inc., all rights reserved.
  11.  
  12.     Change History (most recent first):
  13.  
  14.          <5>     8/19/96    DH        1376276:OpenDoc corrupts document when out
  15.                                     of disk space. Added function
  16.                                     CMGetValueUseCount.
  17.          <4>     8/13/96    DM        1362809: new functions to cause or query
  18.                                     disabled containers
  19.          <2>     6/14/96    NP        10020: remove warnings.
  20.          <5>     5/25/95    jpa        Changed last param of CMOpenNewContainer
  21.                                     for ANSI/CFM68K compatibility. [1241078]
  22.          <4>     3/31/95    EL        1234685: Add CMContainsValidLabel.
  23.          <3>     3/24/95    EL        1209355: add CMTakeSnapShot.
  24.          <2>     8/26/94    EL        #1181622 Ownership update.
  25.          <2>     3/31/94    EL        Add CMMergeContainer call. #1150214
  26.          <8>     3/17/94    EL        Add CMKeepObject call.
  27.          <7>     12/7/93    EL        Add CMGetReferenceForObject call.
  28.          <6>    11/10/93    EL        Add CMCountProperties call.
  29.          <5>     10/6/93    EL        Add CMGetPrevXXXX.
  30.          <4>     9/27/93    VL        Added CMGetPrevObjectProperty and
  31.                                                     CMGetPrevValue.
  32.          <3>      9/8/93    VL        Added GetObject and GetObjectID.
  33.  
  34.     To Do:
  35.     In Progress:
  36.         
  37. */
  38.  
  39. /* (use tabs = 2 to view this file correctly) */
  40. /*---------------------------------------------------------------------------*
  41.  |                                                                           |
  42.  |                             <<< CM_API.h >>>                              |
  43.  |                                                                           |
  44.  |                           Container Manager API                           |
  45.  |                                                                           |
  46.  |                               Ira L. Ruben                                |
  47.  |                                 11/18/91                                  |
  48.  |                                                                           |
  49.  |                  Copyright Apple Computer, Inc. 1991-1995                 |
  50.  |                           All rights reserved.                            |
  51.  |                                                                           |
  52.  *---------------------------------------------------------------------------*
  53.  
  54.  This is the Container Manager API definitions.  All routines needed to communicate with
  55.  the Container Manager are defined here.  This is the only explicit #include needed. All
  56.  other required headers are included from here.
  57.  
  58.  Refer to Container Manager API documentation for details on these routines.
  59.  
  60.  
  61.                                               *------------------------------*
  62.                                                 | NOTE TO DOS (80x86) USERS... |
  63.                                                 *------------------------------*
  64.  
  65.  The Container Manager should be compiled with the "large" memory model so that all
  66.  routines, pointers, etc. are "far".  All external API interfaces are appropriately
  67.  qualified this way.  Since handlers are implementation or user dependent, these files
  68.  must be compiled with the large memory model.  The only exception is local static
  69.  routines which usually can be qualified with "near" (except, of course, for handlers).
  70.  
  71.  This file uses the function and pointer memory model attribute macros defined
  72.  CM_API_Environment.h.  See that file for further details.
  73. */
  74.  
  75. #ifndef __CM_API__
  76. #define __CM_API__
  77.  
  78. #include <stdarg.h>
  79. #include <stdio.h>
  80.  
  81. #ifndef __CM_API_ENV__
  82. #include "CMAPIEnv.h"                                                    /* Environment-specific definitions                */
  83. #endif
  84. #ifndef __CM_API_TYPES__
  85. #include "CMAPITyp.h"                                                    /* API type definitions                                        */
  86. #endif
  87. #ifndef __CM_API_STDOBJIDS__
  88. #include "CMAPIIDs.h"                                                    /* Standard object ID definitions, etc.        */
  89. #endif
  90. #ifndef __CM_API_ERRNO__
  91. #include "CMAPIErr.h"                                                /* Error code numbers and their meaning        */
  92. #endif
  93.  
  94.  
  95.                                                                 CM_CFUNCTIONS
  96.                                                                 
  97. /*---------------------------*
  98.  | Session (task) operations |
  99.  *---------------------------*/
  100.  
  101. CMSession CM_FIXEDARGS CMStartSession(CMMetaHandler metaHandler, CMRefCon sessionRefCon);
  102. void CM_FIXEDARGS CMEndSession(CMSession sessionData, CMBoolean closeOpenContainers);
  103. void CM_FIXEDARGS CMAbortSession(CMSession sessionData);
  104. CMRefCon CM_FIXEDARGS CMGetSessionRefCon(CMContainer container);
  105. void CM_FIXEDARGS CMSetSessionRefCon(CMContainer container, CMRefCon refCon);
  106.  
  107.  
  108. /*--------------------*
  109.  | Handler Operations |
  110.  *--------------------*/
  111.  
  112. CMHandlerAddr CM_FIXEDARGS CMSetMetaHandler(CMconst_CMSession sessionData,
  113.                                                                                         CMconst_CMGlobalName typeName,
  114.                                                                                           CMMetaHandler metaHandler);
  115. CMHandlerAddr CM_FIXEDARGS CMGetMetaHandler(CMconst_CMSession sessionData,
  116.                                                                                         CMconst_CMGlobalName typeName);
  117. CMHandlerAddr CM_FIXEDARGS CMGetOperation(CMType targetType,
  118.                                                                                     CMconst_CMGlobalName operationType);
  119.  
  120.  
  121. /*----------------------*
  122.  | Container Operations |
  123.  *----------------------*/
  124.  
  125. CMContainer CM_FIXEDARGS CMOpenContainer(CMSession sessionData,
  126.                                                                                  CMRefCon attributes,
  127.                                                                                  CMconst_CMGlobalName typeName, 
  128.                                                                                  CMContainerUseMode useFlags);
  129. CMContainer CM_VARARGS CMOpenNewContainer(CMSession sessionData,
  130.                                                                                     CMRefCon attributes,
  131.                                                                                     CMconst_CMGlobalName typeName, 
  132.                                                                                     CMContainerUseMode useFlags,
  133.                                                                                     CMGeneration generation,
  134.                                                                                 /*CMContainerFlags*/ CM_ULONG containerFlags, ...);
  135. CMContainer CM_FIXEDARGS CMVOpenNewContainer(CMSession sessionData,
  136.                                                                                          CMRefCon attributes,
  137.                                                                                          CMconst_CMGlobalName typeName, 
  138.                                                                                          CMContainerUseMode useFlags,
  139.                                                                                          CMGeneration generation,
  140.                                                                                          CMContainerFlags containerFlags,
  141.                                                                                          va_list targetTypeInitParams);
  142. void CM_FIXEDARGS CMCloseContainer(CMconst_CMContainer container);
  143. void CM_FIXEDARGS CMAbortContainer(CMconst_CMContainer container);
  144. void CM_FIXEDARGS CMMergeContainer(CMconst_CMContainer container, CMValue targetValue);
  145. void CM_FIXEDARGS CMGetContainerInfo(CMconst_CMContainer container,
  146.                                                                          CMGeneration CM_PTR *generation, 
  147.                                                                          CM_USHORT CM_PTR *bufSize,
  148.                                                                          CMContainerFlags CM_PTR *containerFlags,
  149.                                                                          CMGlobalName typeName,
  150.                                                                          CMContainerModeFlags CM_PTR *openMode);
  151. CMSession CM_FIXEDARGS CMGetSession(CMContainer container);
  152. void CM_FIXEDARGS CMTakeSnapShot(CMconst_CMContainer container, CMBoolean includeEmbedded);
  153.  
  154. void CM_FIXEDARGS CMDisableContainer(CMContainer container);
  155. CMBoolean CM_FIXEDARGS CMIsDisabledContainer(CMconst_CMContainer container);
  156.  
  157. /*------------------------------*
  158.  | Type and Property Operations |
  159.  *------------------------------*/
  160.  
  161. CMType CM_FIXEDARGS CMRegisterType(CMContainer targetContainer, CMconst_CMGlobalName name);
  162. CMProperty CM_FIXEDARGS CMRegisterProperty(CMContainer targetContainer,
  163.                                                                                      CMconst_CMGlobalName name);
  164. CMCount CM_FIXEDARGS CMAddBaseType(CMType type, CMType baseType);
  165. CMCount CM_FIXEDARGS CMRemoveBaseType(CMType type, CMType baseType);
  166. CMBoolean CM_FIXEDARGS CMIsType(CMObject theObject);
  167. CMBoolean CM_FIXEDARGS CMIsProperty(CMObject theObject);
  168. CMType CM_FIXEDARGS CMGetNextType(CMContainer targetContainer, CMType currType);
  169. CMType CM_FIXEDARGS CMGetPrevType(CMContainer targetContainer, CMType currType);
  170. CMProperty CM_FIXEDARGS CMGetNextProperty(CMContainer targetContainer,
  171.                                                                                     CMProperty currProperty);
  172. CMProperty CM_FIXEDARGS CMGetPrevProperty(CMContainer targetContainer,
  173.                                                                                     CMProperty currProperty);
  174.  
  175.  
  176. /*-------------------*
  177.  | Object Operations |
  178.  *-------------------*/
  179.  
  180. CMObject CM_FIXEDARGS CMNewObject(CMContainer targetContainer);
  181. CMObject CM_FIXEDARGS CMGetNextObject(CMContainer targetContainer, CMObject currObject);
  182. CMObject CM_FIXEDARGS CMGetPrevObject(CMContainer targetContainer, CMObject currObject);
  183. CMProperty CM_FIXEDARGS CMGetNextObjectProperty(CMObject theObject, CMProperty currProperty);
  184. CMProperty CM_FIXEDARGS CMGetPrevObjectProperty(CMObject theObject, CMProperty currProperty);
  185. CMObject CM_FIXEDARGS CMGetNextObjectWithProperty(CMContainer targetContainer,
  186.                                                                                                     CMObject currObject, CMProperty property);
  187. CMObject CM_FIXEDARGS CMGetPrevObjectWithProperty(CMContainer targetContainer,
  188.                                                                                                     CMObject currObject, CMProperty property);
  189. CMContainer CM_FIXEDARGS CMGetObjectContainer(CMObject theObject);
  190. CMGlobalName CM_FIXEDARGS CMGetGlobalName(CMObject theObject);
  191. CMCount CM_FIXEDARGS CMCountProperties(CMObject object, CMProperty property);
  192. CMRefCon CM_FIXEDARGS CMGetObjectRefCon(CMObject theObject);
  193. void CM_FIXEDARGS CMSetObjectRefCon(CMObject theObject, CMRefCon refCon);
  194. void CM_FIXEDARGS CMDeleteObject(CMObject theObject);
  195. void CM_FIXEDARGS CMDeleteObjectProperty(CMObject theObject, CMProperty theProperty);
  196. void CM_FIXEDARGS CMReleaseObject(CMObject theObject);
  197. void CM_FIXEDARGS CMKeepObject(CMObject theObject);
  198. CMObject CM_FIXEDARGS CMGetObject(CMContainer targetContainer, CMObjectID objectID);
  199. CMObjectID CM_FIXEDARGS CMGetObjectID(CMObject object);
  200.  
  201.  
  202. /*------------------*
  203.  | Value Operations |
  204.  *------------------*/
  205.  
  206. CMCount CM_FIXEDARGS CMCountValues(CMObject object, CMProperty property, CMType type);
  207. CMValue CM_FIXEDARGS CMUseValue(CMObject object, CMProperty property, CMType type);
  208. CMValue CM_FIXEDARGS CMGetNextValue(CMObject object, CMProperty property, CMValue currValue);
  209. CMValue CM_FIXEDARGS CMGetPrevValue(CMObject object, CMProperty property, CMValue currValue);
  210. CMValue CM_VARARGS CMNewValue(CMObject object, CMProperty property, CMType type, ...);
  211. CMValue CM_FIXEDARGS CMVNewValue(CMObject object, CMProperty property, CMType type,
  212.                                                                   va_list dataInitParams);
  213. CMValue CM_FIXEDARGS CMGetBaseValue(CMValue value);
  214. CMSize CM_FIXEDARGS CMGetValueSize(CMValue value);
  215. CMCount CM_FIXEDARGS CMGetValueUseCount(CMValue value);
  216. CMSize CM_FIXEDARGS CMReadValueData(CMValue value, CMPtr buffer, CMCount offset, CMSize maxSize);
  217. void CM_FIXEDARGS CMWriteValueData(CMValue value, CMPtr buffer, CMCount offset, CMSize size);
  218. void CM_FIXEDARGS CMDefineValueData(CMValue value, CMCount offset, CMSize size);
  219. void CM_FIXEDARGS CMInsertValueData(CMValue value, CMPtr buffer, CMCount offset, CMSize size);
  220. void CM_FIXEDARGS CMDeleteValueData(CMValue value, CMCount offset, CMSize size);
  221. void CM_FIXEDARGS CMMoveValue(CMValue value, CMObject object, CMProperty property);
  222. void CM_FIXEDARGS CMGetValueInfo(CMValue value, CMContainer CM_PTR *container,
  223.                                                                  CMObject CM_PTR *object, CMProperty CM_PTR *property,
  224.                                                                  CMType CM_PTR *type, CMGeneration CM_PTR *generation);
  225. void CM_FIXEDARGS CMSetValueType(CMValue value, CMType type);
  226. void CM_FIXEDARGS CMSetValueGeneration(CMValue value, CMGeneration generation);
  227. CMContainer CM_FIXEDARGS CMGetValueContainer(CMValue value);
  228. CMRefCon CM_FIXEDARGS CMGetValueRefCon(CMValue value);
  229. void CM_FIXEDARGS CMSetValueRefCon(CMValue value, CMRefCon refCon);
  230. void CM_FIXEDARGS CMDeleteValue(CMValue value);
  231. void CM_FIXEDARGS CMReleaseValue(CMValue value);
  232. CMBoolean CM_FIXEDARGS CMContainsValidLabel(CMValue value);
  233.  
  234.  
  235. /*----------------------*
  236.  | Reference Operations |
  237.  *----------------------*/
  238.  
  239. CMReference CM_PTR * CM_FIXEDARGS CMNewReference(CMValue value,
  240.                                                                                                  CMObject referencedObject,
  241.                                                                                                   CMReference CM_PTR theReferenceData);
  242. CMReference CM_PTR * CM_FIXEDARGS CMSetReference(CMValue value,
  243.                                                                                                  CMObject referencedObject,
  244.                                                                                                   CMReference CM_PTR theReferenceData);
  245. CMObject CM_FIXEDARGS CMGetReferencedObject(CMValue value, CMReference CM_PTR theReferenceData);
  246. CMReference CM_PTR * CM_FIXEDARGS CMGetReferenceForObject(CMValue value, 
  247.                                                                                                                      CMObject referencedObject,
  248.                                                                                                                     CMReference CM_PTR theReferenceData);
  249. void CM_FIXEDARGS CMDeleteReference(CMValue value, CMReference CM_PTR theReferenceData);
  250. CMCount CM_FIXEDARGS CMCountReferences(CMValue value);
  251. CMReference CM_PTR * CM_FIXEDARGS CMGetNextReference(CMValue value,
  252.                                                                                                          CMReference CM_PTR currReferenceData);
  253. CMReference CM_PTR * CM_FIXEDARGS CMGetPrevReference(CMValue value,
  254.                                                                                                          CMReference CM_PTR currReferenceData);
  255.  
  256.  
  257. /*--------------------------*
  258.  | Value Handler Operations |
  259.  *--------------------------*/
  260.  
  261. CMCount CM_VARARGS CMScanDataPacket(CMType type, CMMetaData metaData,
  262.                                                                         CMDataPacket dataPacket, ...);
  263. CMCount CM_FIXEDARGS CMVScanDataPacket(CMType type, CMMetaData metaData,
  264.                                                                              CMDataPacket dataPacket,
  265.                                                                               va_list dataInitParams);
  266.  
  267.  
  268. /*--------------------------*
  269.  | Error Handler Operations |
  270.  *--------------------------*/
  271.  
  272. char CM_PTR * CM_VARARGS CMAddMsgInserts(char CM_PTR *msgString, CMSize maxLength, ...);
  273. char CM_PTR * CM_FIXEDARGS CMVAddMsgInserts(char CM_PTR *msgString, CMSize maxLength,
  274.                                                                                       va_list inserts);
  275. CMErrorString CM_VARARGS CMErrorToFormattedString(CMErrorString errorString, CMSize maxLength, 
  276.                                                                                       CMErrorNbr errorNumber, ...);
  277. CMErrorString CM_FIXEDARGS CMVErrorToFormattedString(CMErrorString errorString, CMSize maxLength, 
  278.                                                                                         CMErrorNbr errorNumber, va_list inserts);
  279. char CM_PTR * CM_FIXEDARGS CMReturnContainerName(CMContainer container);
  280.  
  281.  
  282. /*--------------------------------*
  283.  | Special Environment Operations |
  284.  *--------------------------------*/
  285.  
  286. void CM_PTR * CM_FIXEDARGS CMMalloc(CMSize size, CMSession sessionData);
  287. void CM_FIXEDARGS CMFree(CMPtr ptr, CMSession sessionData);
  288. void CM_VARARGS CMError(CMSession sessionData, CMErrorString message, ...);
  289. void CM_FIXEDARGS CMVError(CMSession sessionData, CMErrorString message, va_list inserts);
  290.  
  291.                                                         CM_END_CFUNCTIONS
  292.  
  293. #endif
  294.